/*
题目描述
设计一个表达式求值的程序 ，支持+，-，*，/，%，（，）以及=运算符组成的表达式的运算。
假设数字只包含int和float，并且全部的表达式都是正确的。
注意表达式向上cast:
除法 1/3=0，1.0/2=0.5
int+float=float
表达式最后的=可以包含也可以不包含

样例输入输出
样例1
输入:
1+1.0
输出:
2.0

样例2
输入:
(5*5)%11*(9+2)
输出:
33

样例3
输入:
19.2+8.67/3=
输出:
22.09

样例4
输入:
9.2*3
输出:
27.599998
 */
import java.util.Scanner;
import java.util.Stack;

public class Main {
    static boolean isExpInt = true;
    // 定义一个内部类，用于存储数字及其类型（整数或浮点数）
    private static class Number {
        float value;
        boolean isInteger;

        Number(float value, boolean isInteger) {
            this.value = value;
            this.isInteger = isInteger;
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String expression = scanner.nextLine();
        scanner.close();

        float result = evaluate(expression);
        if (isExpInt) {
            System.out.println((int)result);
        }
        else System.out.println(result);
    }

    public static float evaluate(String expression) {
        // 去除表达式中的空格和末尾的等号
        expression = expression.replaceAll("\\s+", "").replace("=", "");

        Stack<Number> numbers = new Stack<>();
        Stack<Character> operators = new Stack<>();

        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);

            // 如果是数字，解析整个数字
            if (Character.isDigit(c) || c == '.') {
                StringBuilder sb = new StringBuilder();
                boolean hasDecimal = false; // 标记是否有小数点
                while (i < expression.length() && (Character.isDigit(expression.charAt(i)) || expression.charAt(i) == '.')) {
                    if (expression.charAt(i) == '.') {
                        isExpInt = false;
                        hasDecimal = true;
                    }
                    sb.append(expression.charAt(i++));
                }
                i--;
                float value = Float.parseFloat(sb.toString());
                numbers.push(new Number(value, !hasDecimal)); // 如果没有小数点，则是整数
            }
            // 如果是左括号，压入运算符栈
            else if (c == '(') {
                operators.push(c);
            }
            // 如果是右括号，计算括号内的表达式
            else if (c == ')') {
                while (operators.peek() != '(') {
                    numbers.push(applyOperation(operators.pop(), numbers.pop(), numbers.pop()));
                }
                operators.pop();
            }
            // 如果是运算符，处理优先级
            else if (isOperator(c)) {
                while (!operators.isEmpty() && precedence(operators.peek()) >= precedence(c)) {
                    numbers.push(applyOperation(operators.pop(), numbers.pop(), numbers.pop()));
                }
                operators.push(c);
            }
        }

        // 处理剩余的运算符
        while (!operators.isEmpty()) {
            numbers.push(applyOperation(operators.pop(), numbers.pop(), numbers.pop()));
        }

        return numbers.pop().value;
    }

    private static boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/' || c == '%';
    }

    private static int precedence(char operator) {
        switch (operator) {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
            case '%':
                return 2;
        }
        return -1;
    }

    private static Number applyOperation(char operator, Number b, Number a) {
        // 如果两个操作数都是整数，则进行整数计算
        if (a.isInteger && b.isInteger) {
            int intA = (int) a.value;
            int intB = (int) b.value;
            switch (operator) {
                case '+':
                    return new Number(intA + intB, true);
                case '-':
                    return new Number(intA - intB, true);
                case '*':
                    return new Number(intA * intB, true);
                case '/':
                    return new Number(intA / intB, true); // 整数除法，直接截断小数部分
                case '%':
                    return new Number(intA % intB, true);
            }
        }

        // 如果操作数中有浮点数，则进行浮点数计算
        switch (operator) {
            case '+':
                return new Number(a.value + b.value, false);
            case '-':
                return new Number(a.value - b.value, false);
            case '*':
                return new Number(a.value * b.value, false);
            case '/':
                return new Number(a.value / b.value, false);
            case '%':
                return new Number(a.value % b.value, false);
        }
        return new Number(0, true);
    }
}
